package com.shujia.day07.ketang;


public class Code05InterfaceOperator {
    public static void main(String[] args) {
        /*
            接口：
                什么是接口？
                    接口从字面意思上，或其他事物类比，可以知道，是对当前的某个实例，添加一些入口规范，
                        比如对于笔记本电脑来说，可以通过拓展坞，来给typeC接口的电脑添加更多类型的接口，比如网线接口 USB接口等。
                            而不同接口，定义了不同的规范，可以在规范内，给当前实例添加更多的功能，比如通过网线接口连接网络
                为什么需要接口？
                    对于动物类来说，并不是所有的猫和狗都有 算术或钻火圈等能力，所以对于部分有该功能的猫和狗可以通过接口进行添加能力
                    同时 Java中在继承关系中只能存在有单继承，所以为了弥补这样的缺陷，可以使用接口来外接多种类型的功能


            接口规范：
                1.接口是和类同一级的，不能即有interface和class
                2.接口中定义的方法都是抽象的，并且不需要手动添加 abstract 进行修饰

            定义接口的注意事项：
                1.接口中只能存在有抽象方法，默认会给抽象方法前添加 public abstract
                     在程序运行时，会对当前项目中的所有.java文件进行编译，得到对应的.class编译文件，
                        该文件直接查看，获取不到内容的，所以需要对其中的文件进行做反编译，而idea打开.class文件 会对其进行做反编译
                     可以通过 gui 工具对.class文件进行反编译得到
                2.接口实际上也可以看成是一个特殊的类，编译时，也会生成对应的.class文件
                3.当一个具体的类实现接口时，需要使用implements关键字对其进行实现，并且对接口中的抽象方法进行重写
                4.当一个实体类继承一个类时，可以实现多个接口
                5.接口中定义的变量，会被默认修饰成一个静态常量( public static final )，所以按照命名规范，接口中的变量，需要大写
                6.接口中不能存在有构造方法，接口主要用于提供一个规范，可以多继承，接口中也不能存在有非抽象方法，所以实例对象对接口没有作用
                7.抽象类实现接口时，可以选择不实现其中的抽象方法，因为抽象类的本身就是抽象的，可以存在有抽象方法

         */


        ComputeCat computeCat = new ComputeCat();
        computeCat.compute(30,40);

        computeCat.drillingRing();

        // 当前的sum是一个静态的常量 虽然可以通过对象进行调用，但是不推荐
//        int sum = computeCat.sum;

        System.out.println(ComputeCat.SUM);
        System.out.println(Compute.SUM);

        new ComputeDog().compute(50,60);


    }
}


abstract class Animal {
    int age = 1;

    public abstract void eat();
    public abstract void sleep();
}



class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("🐱爱吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫是躺着睡的");
    }
}


// ComputeCat可以称为是一个子类或者实现类
class ComputeCat extends Animal implements Compute,Drilling {
    int a = 0;
    @Override
    public void eat() {
        System.out.println("🐱爱吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫是躺着睡的");
    }

    @Override
    public void compute(int a, int b) {
        System.out.println("猫能做计算：");
        for (int i = 0; i < a+b; i++) {
            System.out.print("喵");
        }
        System.out.println();
    }

    @Override
    public void drillingRing() {
        System.out.println("猫玩钻火圈，玩的真开心啊...");
    }
}


// interface 表示是接口的关键字和类是同级的
interface Compute{
    int SUM = 0;

    void compute(int a,int b);

    // 接口中只能存在抽象方法
//    void test(){
//        System.out.println("测试...");
//    }

}


// 钻火圈接口
interface Drilling {

//    Drilling(){} 接口中不能存在有构造方法

    void drillingRing();
}


// 如果当狗是一个抽象类时
abstract class Dog extends Animal implements Compute{

    @Override
    public void eat() {
        System.out.println("🐕爱吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("🐕是趴着睡的");
    }

    @Override
    public void compute(int a, int b) {
        System.out.println("🐕能做计算：");
        for (int i = 0; i < a+b; i++) {
            System.out.print("汪");
        }
        System.out.println();
    }
}


// 实例类继承或实现后，要看父类或接口中是否有存在抽象方法，如果有，那么就需要重写
class ComputeDog extends Dog {

//    @Override
//    public void compute(int a, int b) {
//
//    }
}




